﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using DataBase.Presupuesto;
using System.Collections;
using System.Data;
using System.Collections.ObjectModel;
using Model.Presupuesto;
namespace Processes.Presupuesto
{
    public class GestorPresupuesto
    {
        public static void EditarPresupuestoUsado(int gestion, string codigo, int cantidad, double valor)
        {
            try
            {
                if (valor > 1E+30)
                    throw new Exception("El valor unitario es demasiado grande");
                DataBase.Presupuesto.BDPresupuesto.EditarElementoPresupuesto(gestion,codigo,cantidad,valor);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
        public static void validarValores(string valor, string cantidad, string gestion)
        {
            string error="";
            try
            {
                Convert.ToInt32(gestion);
            }
            catch (FormatException)
            {
                error += "-introduzca gestion valida(años entre 1967 y 2022) ";
                error.Trim();
            }
            try
            {
                Convert.ToInt32(cantidad);
            }
            catch (FormatException)
            {
                error += "-introduzca cantidad valida(numeros enteros) ";
                
            }
            try
            {
                Convert.ToDouble(valor);
            }
            catch (FormatException)
            {
                error += "-introduzca valor unitario valido(numeros enteros o decimales)";
            }
            if (!String.IsNullOrEmpty(error))
                throw new Exception(error);
        }
        public static void UsarPresupuesto(string gestion, string codigo, string valor, string cantidad,long programa)
        {
            double valorUnitario=-1;
            int cant=-1,gest=-1;
            string error="";
            if (String.IsNullOrEmpty(codigo))
                throw new Exception("No tiene ningun evento seleccionado");
            try
            {
                //validarValores(valor, cantidad, gestion);
                valorUnitario = Convert.ToDouble(valor);
                if (valorUnitario <= 0) throw new Exception("El valor no puede ser menor o igual a 0");
               
                cant = Convert.ToInt32(cantidad);
                if (cant <= 0) throw new Exception("La cantidad no puede ser menor o igual a 0");
               
                gest = Convert.ToInt32(gestion);

                DataBase.Presupuesto.BDPresupuesto.UsarPresupuesto(gest, codigo, valorUnitario, cant,programa);
            }
            catch (FormatException)
            {
                if (valorUnitario == -1)
                    error = "Favor ingrese valor unitario valido";
                else if (cant == -1)
                    error = "Favor ingrese cantidad valida";
                else if (gest == -1)
                    error = "Favor ingrese una gestion valida";
                else
                    error = "error al crear verifique sus datos";
                throw new Exception(error);
            }
            catch (OverflowException)
            {
                throw new Exception("El valor unitario es demasiado grande");
            }
            catch (Exception exception)
            {
                throw exception;
            }
        }

        public static void EliminarIE(long codigo,int gestion)
        {
            try
            {
                DataBase.Presupuesto.BDPresupuesto.EliminarIE(codigo,gestion);
            }
            catch (Exception exception)
            {
                throw exception;
            }
        }
        public static double Total(string gestion,char tipo)
        {
            try
            {
                int gest=Convert.ToInt32(gestion);
                return DataBase.Presupuesto.BDPresupuesto.Total(gest, tipo);
            }
            catch (FormatException)
            {
                throw new Exception("Ingrese gestion valida");
            }
            catch (Exception exception)
            {
                throw exception;
            }
        }
        public static Collection<IngresoEgreso> getIE(string gestion, char tipo)
        {
            try
            {
                int gest = Convert.ToInt32(gestion);
                if (gest < 1967 || gest > 2022)
                    throw new Exception("gestion debe estar en rango de 1967 y 2022");
                return DataBase.Presupuesto.BDPresupuesto.getIE(gest, tipo);
            }
            catch (FormatException)
            {
                throw new Exception("Ingrese valores numericos");
            }
            catch (Exception ex)
            {
                throw ex;
            }

        }
        public static void RegistrarEvento(string evento,char tipo,string nombre)
        {
            try
            {
                if (String.IsNullOrEmpty(evento) || String.IsNullOrEmpty(nombre))
                    throw new Exception("se requiere ambos campos");
                if (DataBase.Presupuesto.BDPresupuesto.ExisteEvento(nombre,tipo))
                    throw new Exception("Ya existe un evento con este nombre");
                DataBase.Presupuesto.BDPresupuesto.RegistrarEvento(evento,tipo,nombre);
            }
            catch (Exception exception)
            {
                throw exception;
            }
        }
        public static ICollection getIngresos(int gestion,char tipo)
        {
            try
            {

                return DataBase.Presupuesto.BDPresupuesto.getIngresos(gestion,tipo);
            }
            catch (Exception exception)
            {
                throw exception;
            }
        }
        public static bool getEstado(string gestion)
        {
            try
            {
                int presupuesto = Convert.ToInt32(gestion);
                return DataBase.Presupuesto.BDPresupuesto.getEstado(presupuesto);
            }
            catch (FormatException)
            {
                throw new Exception("debe introducir un año valido");
            }
            catch (Exception exception)
            {
                throw exception;
            }
        }
        public static bool existeGestion(string gestion)
        {
            try
            {
                int presupuesto = Convert.ToInt32(gestion);
                return DataBase.Presupuesto.BDPresupuesto.existeGestion(presupuesto);
            }
            catch (FormatException)
            {
                throw new Exception("debe introducir un año valido");
            }
            catch (Exception exception)
            {
                throw exception;
            }
        }
        public static ICollection getPresupuesto(string inicio,string fin,bool todos,bool especifico,bool edicion)
        {
            try
            {
                if (String.IsNullOrEmpty(inicio) || String.IsNullOrEmpty(fin))
                    throw new Exception("No puede dejar el campo vacio");

                int inicial = Convert.ToInt32(inicio);
                int final = Convert.ToInt32(fin);
                if (inicial > final)
                    throw new Exception("La gestion final debe ser mayor o igual a la inicial");
                if (inicial < 1967 || inicial > 2022 || final < 1967 || final > 2022)
                    throw new Exception("Deben estar en el rango de 1967 y 2022");
                return DataBase.Presupuesto.BDPresupuesto.getPresupuestos(inicial, final,todos,especifico,edicion);
            }
            catch (FormatException)
            {
                throw new FormatException("Gestiones invalidas");
            }
            catch (Exception ex)
            {
                throw ex;
            }
        
        }
        
        public static void CerrarPresupuesto(string gestion)
        {
            try
            {
                int presupuesto = Convert.ToInt32(gestion);
                DataBase.Presupuesto.BDPresupuesto.CerrarPresupuesto(presupuesto);
                Processes.GestorIngresoEgreso.CrearIngresoEgreso(presupuesto);
            }
            catch (FormatException)
            {
                throw new Exception("debe introducir un año valido");
            }
            catch (Exception exception)
            {
                throw exception;
            }
        
        }
        public static bool CrearPresupuesto(string gestion)
        {
            try
            {
                
                int presupuesto = Convert.ToInt32(gestion);
                if (presupuesto < 1967 || presupuesto > 2022)
                    throw new Exception("Debe estar en el rango de 1967 y 2022");
                return DataBase.Presupuesto.BDPresupuesto.CrearPresupuesto(presupuesto);
            }
            catch (FormatException)
            {
                throw new Exception("debe introducir un año valido");
            }
            catch (Exception exception)
            {
                throw exception;
            }
        }
    }
}
